/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow1Stride2 = WindowStrideTest<Pair, 1, 2>;
TYPED_TEST_SUITE(ForwardWindow1Stride2, GTestTypeTriples);
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 7., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 7., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 7., 14., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 7., 14., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3., 6.,  9.,  12.,
                                         7., 14., 21., 28., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3., 6.,  9.,  12.,
                                         7., 14., 21., 28., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 41., 53.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 41., 53.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 23., 34.,
                                         55., 82., 71., 106.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 23., 34.,
                                         55., 82., 71., 106.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  83.,  110., 137., 164.,
                                         107., 142., 177., 212.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  83.,  110., 137., 164.,
                                         107., 142., 177., 212.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 270., 350.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 270., 350.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         434., 540., 562., 700.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         434., 540., 562., 700.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90.,  100.,  110.,  120., 314., 356.,
                                         398., 440.,  762.,  868., 974., 1080.,
                                         986., 1124., 1262., 1400.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90.,  100.,  110.,  120., 314., 356.,
                                         398., 440.,  762.,  868., 974., 1080.,
                                         986., 1124., 1262., 1400.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 9., 11.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 9., 11.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 9., 18., 11., 22.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 9., 18., 11., 22.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3.,  6.,  9.,  12.,
                                         9., 18., 27., 36., 11., 22., 33., 44.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3.,  6.,  9.,  12.,
                                         9., 18., 27., 36., 11., 22., 33., 44.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 53., 65.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 53., 65.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23., 34.,
                                         71., 106., 87., 130.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23., 34.,
                                         71., 106., 87., 130.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  107., 142., 177., 212.,
                                         131., 174., 217., 260.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  107., 142., 177., 212.,
                                         131., 174., 217., 260.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 350., 430.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 350., 430.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         562., 700., 690., 860.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         562., 700., 690., 860.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100.,  110.,  120.,  314.,  356.,  398.,  440.,
      986., 1124., 1262., 1400., 1210., 1380., 1550., 1720.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100.,  110.,  120.,  314.,  356.,  398.,  440.,
      986., 1124., 1262., 1400., 1210., 1380., 1550., 1720.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 5., 13., 15., 17.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 5., 13., 15., 17.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  5.,  10.,
                                         13., 26., 15., 30., 17., 34.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  5.,  10.,
                                         13., 26., 15., 30., 17., 34.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12., 5.,  10., 15., 20.,
      13., 26., 39., 52., 15., 30., 45., 60., 17., 34., 51., 68.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12., 5.,  10., 15., 20.,
      13., 26., 39., 52., 15., 30., 45., 60., 17., 34., 51., 68.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 29., 77., 89., 101.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 29., 77., 89., 101.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,   10.,  23.,  34.,  39.,  58.,
                                         103., 154., 119., 178., 135., 202.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,   10.,  23.,  34.,  39.,  58.,
                                         103., 154., 119., 178., 135., 202.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  59.,  78.,  97.,  116.,
      155., 206., 257., 308., 179., 238., 297., 356., 203., 270., 337., 404.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  59.,  78.,  97.,  116.,
      155., 206., 257., 308., 179., 238., 297., 356., 203., 270., 337., 404.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 190., 510., 590., 670.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 190., 510., 590., 670.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50., 60., 178., 220., 306., 380., 818., 1020., 946., 1180., 1074., 1340.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50., 60., 178., 220., 306., 380., 818., 1020., 946., 1180., 1074., 1340.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      538.,  612.,  686.,  760.,  1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 1882., 2148., 2414., 2680.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      538.,  612.,  686.,  760.,  1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 1882., 2148., 2414., 2680.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 7., 9.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 7., 9.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 7., 14., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 7., 14., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3., 6.,  9.,  12.,
                                         7., 14., 21., 28., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3., 6.,  9.,  12.,
                                         7., 14., 21., 28., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 41., 53.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 41., 53.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 23., 34.,
                                         55., 82., 71., 106.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 23., 34.,
                                         55., 82., 71., 106.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  83.,  110., 137., 164.,
                                         107., 142., 177., 212.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  83.,  110., 137., 164.,
                                         107., 142., 177., 212.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 270., 350.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 270., 350.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         434., 540., 562., 700.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         434., 540., 562., 700.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90.,  100.,  110.,  120., 314., 356.,
                                         398., 440.,  762.,  868., 974., 1080.,
                                         986., 1124., 1262., 1400.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90.,  100.,  110.,  120., 314., 356.,
                                         398., 440.,  762.,  868., 974., 1080.,
                                         986., 1124., 1262., 1400.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 9., 11.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 9., 11.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 9., 18., 11., 22.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 6., 9., 18., 11., 22.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3.,  6.,  9.,  12.,
                                         9., 18., 27., 36., 11., 22., 33., 44.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  3.,  6.,  9.,  12.,
                                         9., 18., 27., 36., 11., 22., 33., 44.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 53., 65.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 53., 65.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23., 34.,
                                         71., 106., 87., 130.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23., 34.,
                                         71., 106., 87., 130.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  107., 142., 177., 212.,
                                         131., 174., 217., 260.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11.,  14.,  17.,  20.,  35.,  46.,
                                         57.,  68.,  107., 142., 177., 212.,
                                         131., 174., 217., 260.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 350., 430.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 350., 430.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         562., 700., 690., 860.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,
                                         562., 700., 690., 860.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100.,  110.,  120.,  314.,  356.,  398.,  440.,
      986., 1124., 1262., 1400., 1210., 1380., 1550., 1720.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100.,  110.,  120.,  314.,  356.,  398.,  440.,
      986., 1124., 1262., 1400., 1210., 1380., 1550., 1720.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 5., 13., 15., 17.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 5., 13., 15., 17.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  5.,  10.,
                                         13., 26., 15., 30., 17., 34.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  5.,  10.,
                                         13., 26., 15., 30., 17., 34.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12., 5.,  10., 15., 20.,
      13., 26., 39., 52., 15., 30., 45., 60., 17., 34., 51., 68.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12., 5.,  10., 15., 20.,
      13., 26., 39., 52., 15., 30., 45., 60., 17., 34., 51., 68.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 29., 77., 89., 101.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 29., 77., 89., 101.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,   10.,  23.,  34.,  39.,  58.,
                                         103., 154., 119., 178., 135., 202.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,   10.,  23.,  34.,  39.,  58.,
                                         103., 154., 119., 178., 135., 202.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  59.,  78.,  97.,  116.,
      155., 206., 257., 308., 179., 238., 297., 356., 203., 270., 337., 404.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  59.,  78.,  97.,  116.,
      155., 206., 257., 308., 179., 238., 297., 356., 203., 270., 337., 404.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 190., 510., 590., 670.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 190., 510., 590., 670.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50., 60., 178., 220., 306., 380., 818., 1020., 946., 1180., 1074., 1340.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50., 60., 178., 220., 306., 380., 818., 1020., 946., 1180., 1074., 1340.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      538.,  612.,  686.,  760.,  1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 1882., 2148., 2414., 2680.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      538.,  612.,  686.,  760.,  1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 1882., 2148., 2414., 2680.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 7., 9., 13., 15.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 7., 9., 13., 15.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  6.,  7.,  14.,
                                         9., 18., 13., 26., 15., 30.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  6.,  7.,  14.,
                                         9., 18., 13., 26., 15., 30.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  3.,  6.,  9.,  12., 7.,  14., 21., 28.,
      9., 18., 27., 36., 13., 26., 39., 52., 15., 30., 45., 60.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  3.,  6.,  9.,  12., 7.,  14., 21., 28.,
      9., 18., 27., 36., 13., 26., 39., 52., 15., 30., 45., 60.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 41., 53., 77., 89.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 41., 53., 77., 89.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23.,  34.,  55.,  82.,
                                         71., 106., 103., 154., 119., 178.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23.,  34.,  55.,  82.,
                                         71., 106., 103., 154., 119., 178.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  83.,  110., 137., 164.,
      107., 142., 177., 212., 155., 206., 257., 308., 179., 238., 297., 356.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  83.,  110., 137., 164.,
      107., 142., 177., 212., 155., 206., 257., 308., 179., 238., 297., 356.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 270., 350., 510., 590.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 270., 350., 510., 590.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,  434., 540.,
                                         562., 700., 818., 1020., 946., 1180.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  178., 220.,  434., 540.,
                                         562., 700., 818., 1020., 946., 1180.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      762.,  868.,  974.,  1080., 986.,  1124., 1262., 1400.,
      1434., 1636., 1838., 2040., 1658., 1892., 2126., 2360.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      762.,  868.,  974.,  1080., 986.,  1124., 1262., 1400.,
      1434., 1636., 1838., 2040., 1658., 1892., 2126., 2360.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 9., 11., 17., 19.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 3., 9., 11., 17., 19.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  9.,  18.,
                                         11., 22., 17., 34., 19., 38.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  9.,  18.,
                                         11., 22., 17., 34., 19., 38.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12., 9.,  18., 27., 36.,
      11., 22., 33., 44., 17., 34., 51., 68., 19., 38., 57., 76.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12., 9.,  18., 27., 36.,
      11., 22., 33., 44., 17., 34., 51., 68., 19., 38., 57., 76.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 53., 65., 101., 113.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 17., 53., 65., 101., 113.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23.,  34.,  71.,  106.,
                                         87., 130., 135., 202., 151., 226.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10.,  23.,  34.,  71.,  106.,
                                         87., 130., 135., 202., 151., 226.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  107., 142., 177., 212.,
      131., 174., 217., 260., 203., 270., 337., 404., 227., 302., 377., 452.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  107., 142., 177., 212.,
      131., 174., 217., 260., 203., 270., 337., 404., 227., 302., 377., 452.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 350., 430., 670., 750.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 110., 350., 430., 670., 750.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50., 60., 178., 220., 562., 700., 690., 860., 1074., 1340., 1202., 1500.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50., 60., 178., 220., 562., 700., 690., 860., 1074., 1340., 1202., 1500.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      986.,  1124., 1262., 1400., 1210., 1380., 1550., 1720.,
      1882., 2148., 2414., 2680., 2106., 2404., 2702., 3000.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,
      986.,  1124., 1262., 1400., 1210., 1380., 1550., 1720.,
      1882., 2148., 2414., 2680., 2106., 2404., 2702., 3000.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  5.,  13., 15.,
                                         17., 25., 27., 29.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  5.,  13., 15.,
                                         17., 25., 27., 29.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  5.,  10.,
                                         13., 26., 15., 30., 17., 34.,
                                         25., 50., 27., 54., 29., 58.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  6.,  5.,  10.,
                                         13., 26., 15., 30., 17., 34.,
                                         25., 50., 27., 54., 29., 58.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   3.,  6.,  9.,  12.,  5.,  10., 15., 20.,
      13., 26., 39., 52.,  15., 30., 45., 60.,  17., 34., 51., 68.,
      25., 50., 75., 100., 27., 54., 81., 108., 29., 58., 87., 116.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   3.,  6.,  9.,  12.,  5.,  10., 15., 20.,
      13., 26., 39., 52.,  15., 30., 45., 60.,  17., 34., 51., 68.,
      25., 50., 75., 100., 27., 54., 81., 108., 29., 58., 87., 116.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  29.,  77., 89.,
                                         101., 149., 161., 173.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  29.,  77., 89.,
                                         101., 149., 161., 173.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,   10.,  23.,  34.,  39.,  58.,
                                         103., 154., 119., 178., 135., 202.,
                                         199., 298., 215., 322., 231., 346.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,   10.,  23.,  34.,  39.,  58.,
                                         103., 154., 119., 178., 135., 202.,
                                         199., 298., 215., 322., 231., 346.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  59.,  78.,  97.,  116.,
      155., 206., 257., 308., 179., 238., 297., 356., 203., 270., 337., 404.,
      299., 398., 497., 596., 323., 430., 537., 644., 347., 462., 577., 692.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  59.,  78.,  97.,  116.,
      155., 206., 257., 308., 179., 238., 297., 356., 203., 270., 337., 404.,
      299., 398., 497., 596., 323., 430., 537., 644., 347., 462., 577., 692.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 190.,  510., 590.,
                                         670., 990., 1070., 1150.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 190.,  510., 590.,
                                         670., 990., 1070., 1150.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1586., 1980., 1714., 2140., 1842., 2300.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1586., 1980., 1714., 2140., 1842., 2300.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  538.,
      612.,  686.,  760.,  1434., 1636., 1838., 2040., 1658., 1892.,
      2126., 2360., 1882., 2148., 2414., 2680., 2778., 3172., 3566.,
      3960., 3002., 3428., 3854., 4280., 3226., 3684., 4142., 4600.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  538.,
      612.,  686.,  760.,  1434., 1636., 1838., 2040., 1658., 1892.,
      2126., 2360., 1882., 2148., 2414., 2680., 2778., 3172., 3566.,
      3960., 3002., 3428., 3854., 4280., 3226., 3684., 4142., 4600.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  7.,  9.,  10., 12.,
                                         16., 18., 19., 21., 25., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  7.,  9.,  10., 12.,
                                         16., 18., 19., 21., 25., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  7.,  14., 9.,  18., 10., 20., 12., 24.,
      16., 32., 18., 36., 19., 38., 21., 42., 25., 50., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  7.,  14., 9.,  18., 10., 20., 12., 24.,
      16., 32., 18., 36., 19., 38., 21., 42., 25., 50., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12.,  7.,  14., 21., 28.,
      9.,  18., 27., 36., 10., 20., 30., 40.,  12., 24., 36., 48.,
      16., 32., 48., 64., 18., 36., 54., 72.,  19., 38., 57., 76.,
      21., 42., 63., 84., 25., 50., 75., 100., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  3.,  6.,  9.,  12.,  7.,  14., 21., 28.,
      9.,  18., 27., 36., 10., 20., 30., 40.,  12., 24., 36., 48.,
      16., 32., 48., 64., 18., 36., 54., 72.,  19., 38., 57., 76.,
      21., 42., 63., 84., 25., 50., 75., 100., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  17.,  41.,  53.,  59.,  71.,
                                         95., 107., 113., 125., 149., 161.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  17.,  41.,  53.,  59.,  71.,
                                         95., 107., 113., 125., 149., 161.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  55.,  82.,  71.,  106., 79.,  118., 95.,  142.,
      127., 190., 143., 214., 151., 226., 167., 250., 199., 298., 215., 322.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  55.,  82.,  71.,  106., 79.,  118., 95.,  142.,
      127., 190., 143., 214., 151., 226., 167., 250., 199., 298., 215., 322.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  83.,  110., 137., 164.,
      107., 142., 177., 212., 119., 158., 197., 236., 143., 190., 237., 284.,
      191., 254., 317., 380., 215., 286., 357., 428., 227., 302., 377., 452.,
      251., 334., 417., 500., 299., 398., 497., 596., 323., 430., 537., 644.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  83.,  110., 137., 164.,
      107., 142., 177., 212., 119., 158., 197., 236., 143., 190., 237., 284.,
      191., 254., 317., 380., 215., 286., 357., 428., 227., 302., 377., 452.,
      251., 334., 417., 500., 299., 398., 497., 596., 323., 430., 537., 644.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 270., 350., 390., 470.,
                                         630., 710., 750., 830., 990., 1070.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 270., 350., 390., 470.,
                                         630., 710., 750., 830., 990., 1070.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  434.,  540.,  562.,  700.,
      626.,  780.,  754.,  940.,  1010., 1260., 1138., 1420.,
      1202., 1500., 1330., 1660., 1586., 1980., 1714., 2140.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  434.,  540.,  562.,  700.,
      626.,  780.,  754.,  940.,  1010., 1260., 1138., 1420.,
      1202., 1500., 1330., 1660., 1586., 1980., 1714., 2140.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  762.,  868.,
      974.,  1080., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1322., 1508., 1694., 1880., 1770., 2020., 2270., 2520., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2330., 2660., 2990., 3320.,
      2778., 3172., 3566., 3960., 3002., 3428., 3854., 4280.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  762.,  868.,
      974.,  1080., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1322., 1508., 1694., 1880., 1770., 2020., 2270., 2520., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2330., 2660., 2990., 3320.,
      2778., 3172., 3566., 3960., 3002., 3428., 3854., 4280.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  9.,  11., 13., 15.,
                                         21., 23., 25., 27., 33., 35.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  9.,  11., 13., 15.,
                                         21., 23., 25., 27., 33., 35.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  9.,  18., 11., 22., 13., 26., 15., 30.,
      21., 42., 23., 46., 25., 50., 27., 54., 33., 66., 35., 70.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  9.,  18., 11., 22., 13., 26., 15., 30.,
      21., 42., 23., 46., 25., 50., 27., 54., 33., 66., 35., 70.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   3.,  6.,  9.,  12.,  9.,  18., 27.,  36.,
      11., 22., 33., 44.,  13., 26., 39., 52.,  15., 30., 45.,  60.,
      21., 42., 63., 84.,  23., 46., 69., 92.,  25., 50., 75.,  100.,
      27., 54., 81., 108., 33., 66., 99., 132., 35., 70., 105., 140.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   3.,  6.,  9.,  12.,  9.,  18., 27.,  36.,
      11., 22., 33., 44.,  13., 26., 39., 52.,  15., 30., 45.,  60.,
      21., 42., 63., 84.,  23., 46., 69., 92.,  25., 50., 75.,  100.,
      27., 54., 81., 108., 33., 66., 99., 132., 35., 70., 105., 140.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  53.,  65.,  77.,  89.,
                                         125., 137., 149., 161., 197., 209.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  53.,  65.,  77.,  89.,
                                         125., 137., 149., 161., 197., 209.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  71.,  106., 87.,  130., 103., 154., 119., 178.,
      167., 250., 183., 274., 199., 298., 215., 322., 263., 394., 279., 418.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  71.,  106., 87.,  130., 103., 154., 119., 178.,
      167., 250., 183., 274., 199., 298., 215., 322., 263., 394., 279., 418.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  107., 142., 177., 212.,
      131., 174., 217., 260., 155., 206., 257., 308., 179., 238., 297., 356.,
      251., 334., 417., 500., 275., 366., 457., 548., 299., 398., 497., 596.,
      323., 430., 537., 644., 395., 526., 657., 788., 419., 558., 697., 836.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  107., 142., 177., 212.,
      131., 174., 217., 260., 155., 206., 257., 308., 179., 238., 297., 356.,
      251., 334., 417., 500., 275., 366., 457., 548., 299., 398., 497., 596.,
      323., 430., 537., 644., 395., 526., 657., 788., 419., 558., 697., 836.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 350., 430.,  510.,  590.,
                                         830., 910., 990., 1070., 1310., 1390.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 350., 430.,  510.,  590.,
                                         830., 910., 990., 1070., 1310., 1390.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  562.,  700.,  690.,  860.,
      818.,  1020., 946.,  1180., 1330., 1660., 1458., 1820.,
      1586., 1980., 1714., 2140., 2098., 2620., 2226., 2780.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  562.,  700.,  690.,  860.,
      818.,  1020., 946.,  1180., 1330., 1660., 1458., 1820.,
      1586., 1980., 1714., 2140., 2098., 2620., 2226., 2780.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  986.,  1124.,
      1262., 1400., 1210., 1380., 1550., 1720., 1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 2330., 2660., 2990., 3320., 2554., 2916.,
      3278., 3640., 2778., 3172., 3566., 3960., 3002., 3428., 3854., 4280.,
      3674., 4196., 4718., 5240., 3898., 4452., 5006., 5560.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  986.,  1124.,
      1262., 1400., 1210., 1380., 1550., 1720., 1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 2330., 2660., 2990., 3320., 2554., 2916.,
      3278., 3640., 2778., 3172., 3566., 3960., 3002., 3428., 3854., 4280.,
      3674., 4196., 4718., 5240., 3898., 4452., 5006., 5560.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  5.,  13., 15., 17.,
                                         19., 21., 23., 31., 33., 35.,
                                         37., 39., 41., 49., 51., 53.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  5.,  13., 15., 17.,
                                         19., 21., 23., 31., 33., 35.,
                                         37., 39., 41., 49., 51., 53.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  5.,  10., 13., 26., 15., 30.,  17., 34.,
      19., 38., 21., 42., 23., 46., 31., 62., 33., 66.,  35., 70.,
      37., 74., 39., 78., 41., 82., 49., 98., 51., 102., 53., 106.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  5.,  10., 13., 26., 15., 30.,  17., 34.,
      19., 38., 21., 42., 23., 46., 31., 62., 33., 66.,  35., 70.,
      37., 74., 39., 78., 41., 82., 49., 98., 51., 102., 53., 106.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   3.,  6.,   9.,   12.,  5.,  10.,  15.,  20.,
      13., 26., 39.,  52.,  15., 30.,  45.,  60.,  17., 34.,  51.,  68.,
      19., 38., 57.,  76.,  21., 42.,  63.,  84.,  23., 46.,  69.,  92.,
      31., 62., 93.,  124., 33., 66.,  99.,  132., 35., 70.,  105., 140.,
      37., 74., 111., 148., 39., 78.,  117., 156., 41., 82.,  123., 164.,
      49., 98., 147., 196., 51., 102., 153., 204., 53., 106., 159., 212.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   3.,  6.,   9.,   12.,  5.,  10.,  15.,  20.,
      13., 26., 39.,  52.,  15., 30.,  45.,  60.,  17., 34.,  51.,  68.,
      19., 38., 57.,  76.,  21., 42.,  63.,  84.,  23., 46.,  69.,  92.,
      31., 62., 93.,  124., 33., 66.,  99.,  132., 35., 70.,  105., 140.,
      37., 74., 111., 148., 39., 78.,  117., 156., 41., 82.,  123., 164.,
      49., 98., 147., 196., 51., 102., 153., 204., 53., 106., 159., 212.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  29.,  77.,  89.,  101.,
                                         113., 125., 137., 185., 197., 209.,
                                         221., 233., 245., 293., 305., 317.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  29.,  77.,  89.,  101.,
                                         113., 125., 137., 185., 197., 209.,
                                         221., 233., 245., 293., 305., 317.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  39.,  58.,  103., 154., 119., 178., 135., 202.,
      151., 226., 167., 250., 183., 274., 247., 370., 263., 394., 279., 418.,
      295., 442., 311., 466., 327., 490., 391., 586., 407., 610., 423., 634.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  39.,  58.,  103., 154., 119., 178., 135., 202.,
      151., 226., 167., 250., 183., 274., 247., 370., 263., 394., 279., 418.,
      295., 442., 311., 466., 327., 490., 391., 586., 407., 610., 423., 634.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,  20.,  35.,   46.,  57.,  68.,  59.,   78.,  97.,
      116.,  155.,  206., 257., 308.,  179., 238., 297., 356.,  203., 270.,
      337.,  404.,  227., 302., 377.,  452., 251., 334., 417.,  500., 275.,
      366.,  457.,  548., 371., 494.,  617., 740., 395., 526.,  657., 788.,
      419.,  558.,  697., 836., 443.,  590., 737., 884., 467.,  622., 777.,
      932.,  491.,  654., 817., 980.,  587., 782., 977., 1172., 611., 814.,
      1017., 1220., 635., 846., 1057., 1268.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,  20.,  35.,   46.,  57.,  68.,  59.,   78.,  97.,
      116.,  155.,  206., 257., 308.,  179., 238., 297., 356.,  203., 270.,
      337.,  404.,  227., 302., 377.,  452., 251., 334., 417.,  500., 275.,
      366.,  457.,  548., 371., 494.,  617., 740., 395., 526.,  657., 788.,
      419.,  558.,  697., 836., 443.,  590., 737., 884., 467.,  622., 777.,
      932.,  491.,  654., 817., 980.,  587., 782., 977., 1172., 611., 814.,
      1017., 1220., 635., 846., 1057., 1268.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  190.,  510.,  590.,  670.,  750.,  830.,  910.,
      1230., 1310., 1390., 1470., 1550., 1630., 1950., 2030., 2110.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  190.,  510.,  590.,  670.,  750.,  830.,  910.,
      1230., 1310., 1390., 1470., 1550., 1630., 1950., 2030., 2110.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1202., 1500., 1330., 1660., 1458., 1820.,
      1970., 2460., 2098., 2620., 2226., 2780., 2354., 2940., 2482.,
      3100., 2610., 3260., 3122., 3900., 3250., 4060., 3378., 4220.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1202., 1500., 1330., 1660., 1458., 1820.,
      1970., 2460., 2098., 2620., 2226., 2780., 2354., 2940., 2482.,
      3100., 2610., 3260., 3122., 3900., 3250., 4060., 3378., 4220.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  538.,
      612.,  686.,  760.,  1434., 1636., 1838., 2040., 1658., 1892.,
      2126., 2360., 1882., 2148., 2414., 2680., 2106., 2404., 2702.,
      3000., 2330., 2660., 2990., 3320., 2554., 2916., 3278., 3640.,
      3450., 3940., 4430., 4920., 3674., 4196., 4718., 5240., 3898.,
      4452., 5006., 5560., 4122., 4708., 5294., 5880., 4346., 4964.,
      5582., 6200., 4570., 5220., 5870., 6520., 5466., 6244., 7022.,
      7800., 5690., 6500., 7310., 8120., 5914., 6756., 7598., 8440.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  538.,
      612.,  686.,  760.,  1434., 1636., 1838., 2040., 1658., 1892.,
      2126., 2360., 1882., 2148., 2414., 2680., 2106., 2404., 2702.,
      3000., 2330., 2660., 2990., 3320., 2554., 2916., 3278., 3640.,
      3450., 3940., 4430., 4920., 3674., 4196., 4718., 5240., 3898.,
      4452., 5006., 5560., 4122., 4708., 5294., 5880., 4346., 4964.,
      5582., 6200., 4570., 5220., 5870., 6520., 5466., 6244., 7022.,
      7800., 5690., 6500., 7310., 8120., 5914., 6756., 7598., 8440.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  7.,  9.,  13., 15.,
                                         19., 21., 25., 27., 31., 33.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  7.,  9.,  13., 15.,
                                         19., 21., 25., 27., 31., 33.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  7.,  14., 9.,  18., 13., 26., 15., 30.,
      19., 38., 21., 42., 25., 50., 27., 54., 31., 62., 33., 66.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  7.,  14., 9.,  18., 13., 26., 15., 30.,
      19., 38., 21., 42., 25., 50., 27., 54., 31., 62., 33., 66.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   3.,  6.,  9.,  12.,  7.,  14., 21., 28.,
      9.,  18., 27., 36.,  13., 26., 39., 52.,  15., 30., 45., 60.,
      19., 38., 57., 76.,  21., 42., 63., 84.,  25., 50., 75., 100.,
      27., 54., 81., 108., 31., 62., 93., 124., 33., 66., 99., 132.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,   3.,  6.,  9.,  12.,  7.,  14., 21., 28.,
      9.,  18., 27., 36.,  13., 26., 39., 52.,  15., 30., 45., 60.,
      19., 38., 57., 76.,  21., 42., 63., 84.,  25., 50., 75., 100.,
      27., 54., 81., 108., 31., 62., 93., 124., 33., 66., 99., 132.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  41.,  53.,  77.,  89.,
                                         113., 125., 149., 161., 185., 197.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  41.,  53.,  77.,  89.,
                                         113., 125., 149., 161., 185., 197.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  55.,  82.,  71.,  106., 103., 154., 119., 178.,
      151., 226., 167., 250., 199., 298., 215., 322., 247., 370., 263., 394.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  55.,  82.,  71.,  106., 103., 154., 119., 178.,
      151., 226., 167., 250., 199., 298., 215., 322., 247., 370., 263., 394.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  83.,  110., 137., 164.,
      107., 142., 177., 212., 155., 206., 257., 308., 179., 238., 297., 356.,
      227., 302., 377., 452., 251., 334., 417., 500., 299., 398., 497., 596.,
      323., 430., 537., 644., 371., 494., 617., 740., 395., 526., 657., 788.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  83.,  110., 137., 164.,
      107., 142., 177., 212., 155., 206., 257., 308., 179., 238., 297., 356.,
      227., 302., 377., 452., 251., 334., 417., 500., 299., 398., 497., 596.,
      323., 430., 537., 644., 371., 494., 617., 740., 395., 526., 657., 788.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 270., 350.,  510.,  590.,
                                         750., 830., 990., 1070., 1230., 1310.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  110., 270., 350.,  510.,  590.,
                                         750., 830., 990., 1070., 1230., 1310.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  434.,  540.,  562.,  700.,
      818.,  1020., 946.,  1180., 1202., 1500., 1330., 1660.,
      1586., 1980., 1714., 2140., 1970., 2460., 2098., 2620.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  434.,  540.,  562.,  700.,
      818.,  1020., 946.,  1180., 1202., 1500., 1330., 1660.,
      1586., 1980., 1714., 2140., 1970., 2460., 2098., 2620.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  762.,  868.,
      974.,  1080., 986.,  1124., 1262., 1400., 1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 2106., 2404., 2702., 3000., 2330., 2660.,
      2990., 3320., 2778., 3172., 3566., 3960., 3002., 3428., 3854., 4280.,
      3450., 3940., 4430., 4920., 3674., 4196., 4718., 5240.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  762.,  868.,
      974.,  1080., 986.,  1124., 1262., 1400., 1434., 1636., 1838., 2040.,
      1658., 1892., 2126., 2360., 2106., 2404., 2702., 3000., 2330., 2660.,
      2990., 3320., 2778., 3172., 3566., 3960., 3002., 3428., 3854., 4280.,
      3450., 3940., 4430., 4920., 3674., 4196., 4718., 5240.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  9.,  11., 17., 19.,
                                         25., 27., 33., 35., 41., 43.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  9.,  11., 17., 19.,
                                         25., 27., 33., 35., 41., 43.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  9.,  18., 11., 22., 17., 34., 19., 38.,
      25., 50., 27., 54., 33., 66., 35., 70., 41., 82., 43., 86.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  9.,  18., 11., 22., 17., 34., 19., 38.,
      25., 50., 27., 54., 33., 66., 35., 70., 41., 82., 43., 86.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   3.,  6.,  9.,   12.,  9.,  18., 27.,  36.,
      11., 22., 33.,  44.,  17., 34., 51.,  68.,  19., 38., 57.,  76.,
      25., 50., 75.,  100., 27., 54., 81.,  108., 33., 66., 99.,  132.,
      35., 70., 105., 140., 41., 82., 123., 164., 43., 86., 129., 172.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   3.,  6.,  9.,   12.,  9.,  18., 27.,  36.,
      11., 22., 33.,  44.,  17., 34., 51.,  68.,  19., 38., 57.,  76.,
      25., 50., 75.,  100., 27., 54., 81.,  108., 33., 66., 99.,  132.,
      35., 70., 105., 140., 41., 82., 123., 164., 43., 86., 129., 172.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  53.,  65.,  101., 113.,
                                         149., 161., 197., 209., 245., 257.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  53.,  65.,  101., 113.,
                                         149., 161., 197., 209., 245., 257.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  71.,  106., 87.,  130., 135., 202., 151., 226.,
      199., 298., 215., 322., 263., 394., 279., 418., 327., 490., 343., 514.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  71.,  106., 87.,  130., 135., 202., 151., 226.,
      199., 298., 215., 322., 263., 394., 279., 418., 327., 490., 343., 514.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  107., 142., 177., 212.,
      131., 174., 217., 260., 203., 270., 337., 404., 227., 302., 377., 452.,
      299., 398., 497., 596., 323., 430., 537., 644., 395., 526., 657., 788.,
      419., 558., 697., 836., 491., 654., 817., 980., 515., 686., 857., 1028.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  35.,  46.,  57.,  68.,  107., 142., 177., 212.,
      131., 174., 217., 260., 203., 270., 337., 404., 227., 302., 377., 452.,
      299., 398., 497., 596., 323., 430., 537., 644., 395., 526., 657., 788.,
      419., 558., 697., 836., 491., 654., 817., 980., 515., 686., 857., 1028.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,   110.,  350.,  430.,
                                         670.,  750.,  990.,  1070.,
                                         1310., 1390., 1630., 1710.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,   110.,  350.,  430.,
                                         670.,  750.,  990.,  1070.,
                                         1310., 1390., 1630., 1710.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  562.,  700.,  690.,  860.,
      1074., 1340., 1202., 1500., 1586., 1980., 1714., 2140.,
      2098., 2620., 2226., 2780., 2610., 3260., 2738., 3420.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  562.,  700.,  690.,  860.,
      1074., 1340., 1202., 1500., 1586., 1980., 1714., 2140.,
      2098., 2620., 2226., 2780., 2610., 3260., 2738., 3420.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  986.,  1124.,
      1262., 1400., 1210., 1380., 1550., 1720., 1882., 2148., 2414., 2680.,
      2106., 2404., 2702., 3000., 2778., 3172., 3566., 3960., 3002., 3428.,
      3854., 4280., 3674., 4196., 4718., 5240., 3898., 4452., 5006., 5560.,
      4570., 5220., 5870., 6520., 4794., 5476., 6158., 6840.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  986.,  1124.,
      1262., 1400., 1210., 1380., 1550., 1720., 1882., 2148., 2414., 2680.,
      2106., 2404., 2702., 3000., 2778., 3172., 3566., 3960., 3002., 3428.,
      3854., 4280., 3674., 4196., 4718., 5240., 3898., 4452., 5006., 5560.,
      4570., 5220., 5870., 6520., 4794., 5476., 6158., 6840.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  5.,  13., 15., 17.,
                                         25., 27., 29., 37., 39., 41.,
                                         49., 51., 53., 61., 63., 65.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  5.,  13., 15., 17.,
                                         25., 27., 29., 37., 39., 41.,
                                         49., 51., 53., 61., 63., 65.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,   5.,  10.,  13., 26.,  15., 30.,  17., 34.,
      25., 50., 27., 54.,  29., 58.,  37., 74.,  39., 78.,  41., 82.,
      49., 98., 51., 102., 53., 106., 61., 122., 63., 126., 65., 130.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,   5.,  10.,  13., 26.,  15., 30.,  17., 34.,
      25., 50., 27., 54.,  29., 58.,  37., 74.,  39., 78.,  41., 82.,
      49., 98., 51., 102., 53., 106., 61., 122., 63., 126., 65., 130.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,   4.,   3.,  6.,   9.,   12.,  5.,  10.,  15.,  20.,
      13., 26.,  39.,  52.,  15., 30.,  45.,  60.,  17., 34.,  51.,  68.,
      25., 50.,  75.,  100., 27., 54.,  81.,  108., 29., 58.,  87.,  116.,
      37., 74.,  111., 148., 39., 78.,  117., 156., 41., 82.,  123., 164.,
      49., 98.,  147., 196., 51., 102., 153., 204., 53., 106., 159., 212.,
      61., 122., 183., 244., 63., 126., 189., 252., 65., 130., 195., 260.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,   4.,   3.,  6.,   9.,   12.,  5.,  10.,  15.,  20.,
      13., 26.,  39.,  52.,  15., 30.,  45.,  60.,  17., 34.,  51.,  68.,
      25., 50.,  75.,  100., 27., 54.,  81.,  108., 29., 58.,  87.,  116.,
      37., 74.,  111., 148., 39., 78.,  117., 156., 41., 82.,  123., 164.,
      49., 98.,  147., 196., 51., 102., 153., 204., 53., 106., 159., 212.,
      61., 122., 183., 244., 63., 126., 189., 252., 65., 130., 195., 260.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  29.,  77.,  89.,  101.,
                                         149., 161., 173., 221., 233., 245.,
                                         293., 305., 317., 365., 377., 389.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  29.,  77.,  89.,  101.,
                                         149., 161., 173., 221., 233., 245.,
                                         293., 305., 317., 365., 377., 389.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  39.,  58.,  103., 154., 119., 178., 135., 202.,
      199., 298., 215., 322., 231., 346., 295., 442., 311., 466., 327., 490.,
      391., 586., 407., 610., 423., 634., 487., 730., 503., 754., 519., 778.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  39.,  58.,  103., 154., 119., 178., 135., 202.,
      199., 298., 215., 322., 231., 346., 295., 442., 311., 466., 327., 490.,
      391., 586., 407., 610., 423., 634., 487., 730., 503., 754., 519., 778.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,  20.,   35.,   46.,  57.,  68.,   59.,   78.,  97.,
      116.,  155.,  206., 257.,  308.,  179., 238., 297.,  356.,  203., 270.,
      337.,  404.,  299., 398.,  497.,  596., 323., 430.,  537.,  644., 347.,
      462.,  577.,  692., 443.,  590.,  737., 884., 467.,  622.,  777., 932.,
      491.,  654.,  817., 980.,  587.,  782., 977., 1172., 611.,  814., 1017.,
      1220., 635.,  846., 1057., 1268., 731., 974., 1217., 1460., 755., 1006.,
      1257., 1508., 779., 1038., 1297., 1556.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,  20.,   35.,   46.,  57.,  68.,   59.,   78.,  97.,
      116.,  155.,  206., 257.,  308.,  179., 238., 297.,  356.,  203., 270.,
      337.,  404.,  299., 398.,  497.,  596., 323., 430.,  537.,  644., 347.,
      462.,  577.,  692., 443.,  590.,  737., 884., 467.,  622.,  777., 932.,
      491.,  654.,  817., 980.,  587.,  782., 977., 1172., 611.,  814., 1017.,
      1220., 635.,  846., 1057., 1268., 731., 974., 1217., 1460., 755., 1006.,
      1257., 1508., 779., 1038., 1297., 1556.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  190.,  510.,  590.,  670.,  990.,  1070., 1150.,
      1470., 1550., 1630., 1950., 2030., 2110., 2430., 2510., 2590.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  190.,  510.,  590.,  670.,  990.,  1070., 1150.,
      1470., 1550., 1630., 1950., 2030., 2110., 2430., 2510., 2590.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1586., 1980., 1714., 2140., 1842., 2300.,
      2354., 2940., 2482., 3100., 2610., 3260., 3122., 3900., 3250.,
      4060., 3378., 4220., 3890., 4860., 4018., 5020., 4146., 5180.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1586., 1980., 1714., 2140., 1842., 2300.,
      2354., 2940., 2482., 3100., 2610., 3260., 3122., 3900., 3250.,
      4060., 3378., 4220., 3890., 4860., 4018., 5020., 4146., 5180.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,   356.,  398.,  440.,  538.,
      612.,  686.,  760.,  1434., 1636.,  1838., 2040., 1658., 1892.,
      2126., 2360., 1882., 2148., 2414.,  2680., 2778., 3172., 3566.,
      3960., 3002., 3428., 3854., 4280.,  3226., 3684., 4142., 4600.,
      4122., 4708., 5294., 5880., 4346.,  4964., 5582., 6200., 4570.,
      5220., 5870., 6520., 5466., 6244.,  7022., 7800., 5690., 6500.,
      7310., 8120., 5914., 6756., 7598.,  8440., 6810., 7780., 8750.,
      9720., 7034., 8036., 9038., 10040., 7258., 8292., 9326., 10360.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,   356.,  398.,  440.,  538.,
      612.,  686.,  760.,  1434., 1636.,  1838., 2040., 1658., 1892.,
      2126., 2360., 1882., 2148., 2414.,  2680., 2778., 3172., 3566.,
      3960., 3002., 3428., 3854., 4280.,  3226., 3684., 4142., 4600.,
      4122., 4708., 5294., 5880., 4346.,  4964., 5582., 6200., 4570.,
      5220., 5870., 6520., 5466., 6244.,  7022., 7800., 5690., 6500.,
      7310., 8120., 5914., 6756., 7598.,  8440., 6810., 7780., 8750.,
      9720., 7034., 8036., 9038., 10040., 7258., 8292., 9326., 10360.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  7.,  9.,  13., 15.,
                                         19., 21., 25., 27., 31., 33.,
                                         37., 39., 43., 45., 49., 51.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  7.,  9.,  13., 15.,
                                         19., 21., 25., 27., 31., 33.,
                                         37., 39., 43., 45., 49., 51.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  7.,  14., 9.,  18., 13., 26., 15., 30.,
      19., 38., 21., 42., 25., 50., 27., 54., 31., 62., 33., 66.,
      37., 74., 39., 78., 43., 86., 45., 90., 49., 98., 51., 102.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,  7.,  14., 9.,  18., 13., 26., 15., 30.,
      19., 38., 21., 42., 25., 50., 27., 54., 31., 62., 33., 66.,
      37., 74., 39., 78., 43., 86., 45., 90., 49., 98., 51., 102.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   3.,  6.,  9.,   12.,  7.,  14.,  21.,  28.,
      9.,  18., 27.,  36.,  13., 26., 39.,  52.,  15., 30.,  45.,  60.,
      19., 38., 57.,  76.,  21., 42., 63.,  84.,  25., 50.,  75.,  100.,
      27., 54., 81.,  108., 31., 62., 93.,  124., 33., 66.,  99.,  132.,
      37., 74., 111., 148., 39., 78., 117., 156., 43., 86.,  129., 172.,
      45., 90., 135., 180., 49., 98., 147., 196., 51., 102., 153., 204.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   3.,  6.,  9.,   12.,  7.,  14.,  21.,  28.,
      9.,  18., 27.,  36.,  13., 26., 39.,  52.,  15., 30.,  45.,  60.,
      19., 38., 57.,  76.,  21., 42., 63.,  84.,  25., 50.,  75.,  100.,
      27., 54., 81.,  108., 31., 62., 93.,  124., 33., 66.,  99.,  132.,
      37., 74., 111., 148., 39., 78., 117., 156., 43., 86.,  129., 172.,
      45., 90., 135., 180., 49., 98., 147., 196., 51., 102., 153., 204.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  41.,  53.,  77.,  89.,
                                         113., 125., 149., 161., 185., 197.,
                                         221., 233., 257., 269., 293., 305.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  41.,  53.,  77.,  89.,
                                         113., 125., 149., 161., 185., 197.,
                                         221., 233., 257., 269., 293., 305.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  55.,  82.,  71.,  106., 103., 154., 119., 178.,
      151., 226., 167., 250., 199., 298., 215., 322., 247., 370., 263., 394.,
      295., 442., 311., 466., 343., 514., 359., 538., 391., 586., 407., 610.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  55.,  82.,  71.,  106., 103., 154., 119., 178.,
      151., 226., 167., 250., 199., 298., 215., 322., 247., 370., 263., 394.,
      295., 442., 311., 466., 343., 514., 359., 538., 391., 586., 407., 610.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,   17.,  20.,  35.,   46.,  57.,  68.,  83.,   110., 137.,
      164., 107.,  142., 177., 212.,  155., 206., 257., 308.,  179., 238.,
      297., 356.,  227., 302., 377.,  452., 251., 334., 417.,  500., 299.,
      398., 497.,  596., 323., 430.,  537., 644., 371., 494.,  617., 740.,
      395., 526.,  657., 788., 443.,  590., 737., 884., 467.,  622., 777.,
      932., 515.,  686., 857., 1028., 539., 718., 897., 1076., 587., 782.,
      977., 1172., 611., 814., 1017., 1220.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,   17.,  20.,  35.,   46.,  57.,  68.,  83.,   110., 137.,
      164., 107.,  142., 177., 212.,  155., 206., 257., 308.,  179., 238.,
      297., 356.,  227., 302., 377.,  452., 251., 334., 417.,  500., 299.,
      398., 497.,  596., 323., 430.,  537., 644., 371., 494.,  617., 740.,
      395., 526.,  657., 788., 443.,  590., 737., 884., 467.,  622., 777.,
      932., 515.,  686., 857., 1028., 539., 718., 897., 1076., 587., 782.,
      977., 1172., 611., 814., 1017., 1220.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  270.,  350.,  510.,  590.,  750.,  830.,  990.,
      1070., 1230., 1310., 1470., 1550., 1710., 1790., 1950., 2030.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  270.,  350.,  510.,  590.,  750.,  830.,  990.,
      1070., 1230., 1310., 1470., 1550., 1710., 1790., 1950., 2030.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  434.,  540.,  562.,  700.,  818.,
      1020., 946.,  1180., 1202., 1500., 1330., 1660., 1586., 1980.,
      1714., 2140., 1970., 2460., 2098., 2620., 2354., 2940., 2482.,
      3100., 2738., 3420., 2866., 3580., 3122., 3900., 3250., 4060.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  434.,  540.,  562.,  700.,  818.,
      1020., 946.,  1180., 1202., 1500., 1330., 1660., 1586., 1980.,
      1714., 2140., 1970., 2460., 2098., 2620., 2354., 2940., 2482.,
      3100., 2738., 3420., 2866., 3580., 3122., 3900., 3250., 4060.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  762.,
      868.,  974.,  1080., 986.,  1124., 1262., 1400., 1434., 1636.,
      1838., 2040., 1658., 1892., 2126., 2360., 2106., 2404., 2702.,
      3000., 2330., 2660., 2990., 3320., 2778., 3172., 3566., 3960.,
      3002., 3428., 3854., 4280., 3450., 3940., 4430., 4920., 3674.,
      4196., 4718., 5240., 4122., 4708., 5294., 5880., 4346., 4964.,
      5582., 6200., 4794., 5476., 6158., 6840., 5018., 5732., 6446.,
      7160., 5466., 6244., 7022., 7800., 5690., 6500., 7310., 8120.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,  356.,  398.,  440.,  762.,
      868.,  974.,  1080., 986.,  1124., 1262., 1400., 1434., 1636.,
      1838., 2040., 1658., 1892., 2126., 2360., 2106., 2404., 2702.,
      3000., 2330., 2660., 2990., 3320., 2778., 3172., 3566., 3960.,
      3002., 3428., 3854., 4280., 3450., 3940., 4430., 4920., 3674.,
      4196., 4718., 5240., 4122., 4708., 5294., 5880., 4346., 4964.,
      5582., 6200., 4794., 5476., 6158., 6840., 5018., 5732., 6446.,
      7160., 5466., 6244., 7022., 7800., 5690., 6500., 7310., 8120.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  9.,  11., 17., 19.,
                                         25., 27., 33., 35., 41., 43.,
                                         49., 51., 57., 59., 65., 67.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  3.,  9.,  11., 17., 19.,
                                         25., 27., 33., 35., 41., 43.,
                                         49., 51., 57., 59., 65., 67.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,   9.,  18.,  11., 22.,  17., 34.,  19., 38.,
      25., 50., 27., 54.,  33., 66.,  35., 70.,  41., 82.,  43., 86.,
      49., 98., 51., 102., 57., 114., 59., 118., 65., 130., 67., 134.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  6.,   9.,  18.,  11., 22.,  17., 34.,  19., 38.,
      25., 50., 27., 54.,  33., 66.,  35., 70.,  41., 82.,  43., 86.,
      49., 98., 51., 102., 57., 114., 59., 118., 65., 130., 67., 134.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,   4.,   3.,  6.,   9.,   12.,  9.,  18.,  27.,  36.,
      11., 22.,  33.,  44.,  17., 34.,  51.,  68.,  19., 38.,  57.,  76.,
      25., 50.,  75.,  100., 27., 54.,  81.,  108., 33., 66.,  99.,  132.,
      35., 70.,  105., 140., 41., 82.,  123., 164., 43., 86.,  129., 172.,
      49., 98.,  147., 196., 51., 102., 153., 204., 57., 114., 171., 228.,
      59., 118., 177., 236., 65., 130., 195., 260., 67., 134., 201., 268.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,   4.,   3.,  6.,   9.,   12.,  9.,  18.,  27.,  36.,
      11., 22.,  33.,  44.,  17., 34.,  51.,  68.,  19., 38.,  57.,  76.,
      25., 50.,  75.,  100., 27., 54.,  81.,  108., 33., 66.,  99.,  132.,
      35., 70.,  105., 140., 41., 82.,  123., 164., 43., 86.,  129., 172.,
      49., 98.,  147., 196., 51., 102., 153., 204., 57., 114., 171., 228.,
      59., 118., 177., 236., 65., 130., 195., 260., 67., 134., 201., 268.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  53.,  65.,  101., 113.,
                                         149., 161., 197., 209., 245., 257.,
                                         293., 305., 341., 353., 389., 401.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   17.,  53.,  65.,  101., 113.,
                                         149., 161., 197., 209., 245., 257.,
                                         293., 305., 341., 353., 389., 401.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  71.,  106., 87.,  130., 135., 202., 151., 226.,
      199., 298., 215., 322., 263., 394., 279., 418., 327., 490., 343., 514.,
      391., 586., 407., 610., 455., 682., 471., 706., 519., 778., 535., 802.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  23.,  34.,  71.,  106., 87.,  130., 135., 202., 151., 226.,
      199., 298., 215., 322., 263., 394., 279., 418., 327., 490., 343., 514.,
      391., 586., 407., 610., 455., 682., 471., 706., 519., 778., 535., 802.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,  20.,   35.,   46.,  57.,  68.,   107.,  142., 177.,
      212.,  131.,  174., 217.,  260.,  203., 270., 337.,  404.,  227., 302.,
      377.,  452.,  299., 398.,  497.,  596., 323., 430.,  537.,  644., 395.,
      526.,  657.,  788., 419.,  558.,  697., 836., 491.,  654.,  817., 980.,
      515.,  686.,  857., 1028., 587.,  782., 977., 1172., 611.,  814., 1017.,
      1220., 683.,  910., 1137., 1364., 707., 942., 1177., 1412., 779., 1038.,
      1297., 1556., 803., 1070., 1337., 1604.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,  20.,   35.,   46.,  57.,  68.,   107.,  142., 177.,
      212.,  131.,  174., 217.,  260.,  203., 270., 337.,  404.,  227., 302.,
      377.,  452.,  299., 398.,  497.,  596., 323., 430.,  537.,  644., 395.,
      526.,  657.,  788., 419.,  558.,  697., 836., 491.,  654.,  817., 980.,
      515.,  686.,  857., 1028., 587.,  782., 977., 1172., 611.,  814., 1017.,
      1220., 683.,  910., 1137., 1364., 707., 942., 1177., 1412., 779., 1038.,
      1297., 1556., 803., 1070., 1337., 1604.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  350.,  430.,  670.,  750.,  990.,  1070., 1310.,
      1390., 1630., 1710., 1950., 2030., 2270., 2350., 2590., 2670.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  350.,  430.,  670.,  750.,  990.,  1070., 1310.,
      1390., 1630., 1710., 1950., 2030., 2270., 2350., 2590., 2670.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  562.,  700.,  690.,  860.,  1074.,
      1340., 1202., 1500., 1586., 1980., 1714., 2140., 2098., 2620.,
      2226., 2780., 2610., 3260., 2738., 3420., 3122., 3900., 3250.,
      4060., 3634., 4540., 3762., 4700., 4146., 5180., 4274., 5340.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  562.,  700.,  690.,  860.,  1074.,
      1340., 1202., 1500., 1586., 1980., 1714., 2140., 2098., 2620.,
      2226., 2780., 2610., 3260., 2738., 3420., 3122., 3900., 3250.,
      4060., 3634., 4540., 3762., 4700., 4146., 5180., 4274., 5340.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,   356.,  398.,  440.,  986.,
      1124., 1262., 1400., 1210., 1380.,  1550., 1720., 1882., 2148.,
      2414., 2680., 2106., 2404., 2702.,  3000., 2778., 3172., 3566.,
      3960., 3002., 3428., 3854., 4280.,  3674., 4196., 4718., 5240.,
      3898., 4452., 5006., 5560., 4570.,  5220., 5870., 6520., 4794.,
      5476., 6158., 6840., 5466., 6244.,  7022., 7800., 5690., 6500.,
      7310., 8120., 6362., 7268., 8174.,  9080., 6586., 7524., 8462.,
      9400., 7258., 8292., 9326., 10360., 7482., 8548., 9614., 10680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  314.,   356.,  398.,  440.,  986.,
      1124., 1262., 1400., 1210., 1380.,  1550., 1720., 1882., 2148.,
      2414., 2680., 2106., 2404., 2702.,  3000., 2778., 3172., 3566.,
      3960., 3002., 3428., 3854., 4280.,  3674., 4196., 4718., 5240.,
      3898., 4452., 5006., 5560., 4570.,  5220., 5870., 6520., 4794.,
      5476., 6158., 6840., 5466., 6244.,  7022., 7800., 5690., 6500.,
      7310., 8120., 6362., 7268., 8174.,  9080., 6586., 7524., 8462.,
      9400., 7258., 8292., 9326., 10360., 7482., 8548., 9614., 10680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  3.,  5.,  13., 15., 17., 25., 27., 29., 37., 39., 41., 49., 51.,
      53., 61., 63., 65., 73., 75., 77., 85., 87., 89., 97., 99., 101.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  3.,  5.,  13., 15., 17., 25., 27., 29., 37., 39., 41., 49., 51.,
      53., 61., 63., 65., 73., 75., 77., 85., 87., 89., 97., 99., 101.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   6.,   5.,   10.,  13.,  26.,  15.,  30.,  17.,
      34.,  25.,  50.,  27.,  54.,  29.,  58.,  37.,  74.,  39.,  78.,
      41.,  82.,  49.,  98.,  51.,  102., 53.,  106., 61.,  122., 63.,
      126., 65.,  130., 73.,  146., 75.,  150., 77.,  154., 85.,  170.,
      87.,  174., 89.,  178., 97.,  194., 99.,  198., 101., 202.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   6.,   5.,   10.,  13.,  26.,  15.,  30.,  17.,
      34.,  25.,  50.,  27.,  54.,  29.,  58.,  37.,  74.,  39.,  78.,
      41.,  82.,  49.,  98.,  51.,  102., 53.,  106., 61.,  122., 63.,
      126., 65.,  130., 73.,  146., 75.,  150., 77.,  154., 85.,  170.,
      87.,  174., 89.,  178., 97.,  194., 99.,  198., 101., 202.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,   4.,   3.,  6.,   9.,   12.,  5.,   10.,  15.,  20.,
      13., 26.,  39.,  52.,  15., 30.,  45.,  60.,  17.,  34.,  51.,  68.,
      25., 50.,  75.,  100., 27., 54.,  81.,  108., 29.,  58.,  87.,  116.,
      37., 74.,  111., 148., 39., 78.,  117., 156., 41.,  82.,  123., 164.,
      49., 98.,  147., 196., 51., 102., 153., 204., 53.,  106., 159., 212.,
      61., 122., 183., 244., 63., 126., 189., 252., 65.,  130., 195., 260.,
      73., 146., 219., 292., 75., 150., 225., 300., 77.,  154., 231., 308.,
      85., 170., 255., 340., 87., 174., 261., 348., 89.,  178., 267., 356.,
      97., 194., 291., 388., 99., 198., 297., 396., 101., 202., 303., 404.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,   4.,   3.,  6.,   9.,   12.,  5.,   10.,  15.,  20.,
      13., 26.,  39.,  52.,  15., 30.,  45.,  60.,  17.,  34.,  51.,  68.,
      25., 50.,  75.,  100., 27., 54.,  81.,  108., 29.,  58.,  87.,  116.,
      37., 74.,  111., 148., 39., 78.,  117., 156., 41.,  82.,  123., 164.,
      49., 98.,  147., 196., 51., 102., 153., 204., 53.,  106., 159., 212.,
      61., 122., 183., 244., 63., 126., 189., 252., 65.,  130., 195., 260.,
      73., 146., 219., 292., 75., 150., 225., 300., 77.,  154., 231., 308.,
      85., 170., 255., 340., 87., 174., 261., 348., 89.,  178., 267., 356.,
      97., 194., 291., 388., 99., 198., 297., 396., 101., 202., 303., 404.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   17.,  29.,  77.,  89.,  101., 149., 161., 173.,
      221., 233., 245., 293., 305., 317., 365., 377., 389.,
      437., 449., 461., 509., 521., 533., 581., 593., 605.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   17.,  29.,  77.,  89.,  101., 149., 161., 173.,
      221., 233., 245., 293., 305., 317., 365., 377., 389.,
      437., 449., 461., 509., 521., 533., 581., 593., 605.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,   23.,  34.,   39.,  58.,   103., 154.,  119., 178., 135.,
      202., 199.,  298., 215.,  322., 231.,  346., 295.,  442., 311., 466.,
      327., 490.,  391., 586.,  407., 610.,  423., 634.,  487., 730., 503.,
      754., 519.,  778., 583.,  874., 599.,  898., 615.,  922., 679., 1018.,
      695., 1042., 711., 1066., 775., 1162., 791., 1186., 807., 1210.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,   23.,  34.,   39.,  58.,   103., 154.,  119., 178., 135.,
      202., 199.,  298., 215.,  322., 231.,  346., 295.,  442., 311., 466.,
      327., 490.,  391., 586.,  407., 610.,  423., 634.,  487., 730., 503.,
      754., 519.,  778., 583.,  874., 599.,  898., 615.,  922., 679., 1018.,
      695., 1042., 711., 1066., 775., 1162., 791., 1186., 807., 1210.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,   20.,   35.,   46.,   57.,   68.,   59.,   78.,
      97.,   116.,  155.,  206.,  257.,  308.,  179.,  238.,  297.,  356.,
      203.,  270.,  337.,  404.,  299.,  398.,  497.,  596.,  323.,  430.,
      537.,  644.,  347.,  462.,  577.,  692.,  443.,  590.,  737.,  884.,
      467.,  622.,  777.,  932.,  491.,  654.,  817.,  980.,  587.,  782.,
      977.,  1172., 611.,  814.,  1017., 1220., 635.,  846.,  1057., 1268.,
      731.,  974.,  1217., 1460., 755.,  1006., 1257., 1508., 779.,  1038.,
      1297., 1556., 875.,  1166., 1457., 1748., 899.,  1198., 1497., 1796.,
      923.,  1230., 1537., 1844., 1019., 1358., 1697., 2036., 1043., 1390.,
      1737., 2084., 1067., 1422., 1777., 2132., 1163., 1550., 1937., 2324.,
      1187., 1582., 1977., 2372., 1211., 1614., 2017., 2420.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,   17.,   20.,   35.,   46.,   57.,   68.,   59.,   78.,
      97.,   116.,  155.,  206.,  257.,  308.,  179.,  238.,  297.,  356.,
      203.,  270.,  337.,  404.,  299.,  398.,  497.,  596.,  323.,  430.,
      537.,  644.,  347.,  462.,  577.,  692.,  443.,  590.,  737.,  884.,
      467.,  622.,  777.,  932.,  491.,  654.,  817.,  980.,  587.,  782.,
      977.,  1172., 611.,  814.,  1017., 1220., 635.,  846.,  1057., 1268.,
      731.,  974.,  1217., 1460., 755.,  1006., 1257., 1508., 779.,  1038.,
      1297., 1556., 875.,  1166., 1457., 1748., 899.,  1198., 1497., 1796.,
      923.,  1230., 1537., 1844., 1019., 1358., 1697., 2036., 1043., 1390.,
      1737., 2084., 1067., 1422., 1777., 2132., 1163., 1550., 1937., 2324.,
      1187., 1582., 1977., 2372., 1211., 1614., 2017., 2420.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  190.,  510.,  590.,  670.,  990.,  1070., 1150.,
      1470., 1550., 1630., 1950., 2030., 2110., 2430., 2510., 2590.,
      2910., 2990., 3070., 3390., 3470., 3550., 3870., 3950., 4030.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   110.,  190.,  510.,  590.,  670.,  990.,  1070., 1150.,
      1470., 1550., 1630., 1950., 2030., 2110., 2430., 2510., 2590.,
      2910., 2990., 3070., 3390., 3470., 3550., 3870., 3950., 4030.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1586., 1980., 1714., 2140., 1842., 2300.,
      2354., 2940., 2482., 3100., 2610., 3260., 3122., 3900., 3250.,
      4060., 3378., 4220., 3890., 4860., 4018., 5020., 4146., 5180.,
      4658., 5820., 4786., 5980., 4914., 6140., 5426., 6780., 5554.,
      6940., 5682., 7100., 6194., 7740., 6322., 7900., 6450., 8060.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   178.,  220.,  306.,  380.,  818.,  1020., 946.,
      1180., 1074., 1340., 1586., 1980., 1714., 2140., 1842., 2300.,
      2354., 2940., 2482., 3100., 2610., 3260., 3122., 3900., 3250.,
      4060., 3378., 4220., 3890., 4860., 4018., 5020., 4146., 5180.,
      4658., 5820., 4786., 5980., 4914., 6140., 5426., 6780., 5554.,
      6940., 5682., 7100., 6194., 7740., 6322., 7900., 6450., 8060.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,    100.,   110.,   120.,   314.,   356.,   398.,   440.,   538.,
      612.,   686.,   760.,   1434.,  1636.,  1838.,  2040.,  1658.,  1892.,
      2126.,  2360.,  1882.,  2148.,  2414.,  2680.,  2778.,  3172.,  3566.,
      3960.,  3002.,  3428.,  3854.,  4280.,  3226.,  3684.,  4142.,  4600.,
      4122.,  4708.,  5294.,  5880.,  4346.,  4964.,  5582.,  6200.,  4570.,
      5220.,  5870.,  6520.,  5466.,  6244.,  7022.,  7800.,  5690.,  6500.,
      7310.,  8120.,  5914.,  6756.,  7598.,  8440.,  6810.,  7780.,  8750.,
      9720.,  7034.,  8036.,  9038.,  10040., 7258.,  8292.,  9326.,  10360.,
      8154.,  9316.,  10478., 11640., 8378.,  9572.,  10766., 11960., 8602.,
      9828.,  11054., 12280., 9498.,  10852., 12206., 13560., 9722.,  11108.,
      12494., 13880., 9946.,  11364., 12782., 14200., 10842., 12388., 13934.,
      15480., 11066., 12644., 14222., 15800., 11290., 12900., 14510., 16120.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride2, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,    100.,   110.,   120.,   314.,   356.,   398.,   440.,   538.,
      612.,   686.,   760.,   1434.,  1636.,  1838.,  2040.,  1658.,  1892.,
      2126.,  2360.,  1882.,  2148.,  2414.,  2680.,  2778.,  3172.,  3566.,
      3960.,  3002.,  3428.,  3854.,  4280.,  3226.,  3684.,  4142.,  4600.,
      4122.,  4708.,  5294.,  5880.,  4346.,  4964.,  5582.,  6200.,  4570.,
      5220.,  5870.,  6520.,  5466.,  6244.,  7022.,  7800.,  5690.,  6500.,
      7310.,  8120.,  5914.,  6756.,  7598.,  8440.,  6810.,  7780.,  8750.,
      9720.,  7034.,  8036.,  9038.,  10040., 7258.,  8292.,  9326.,  10360.,
      8154.,  9316.,  10478., 11640., 8378.,  9572.,  10766., 11960., 8602.,
      9828.,  11054., 12280., 9498.,  10852., 12206., 13560., 9722.,  11108.,
      12494., 13880., 9946.,  11364., 12782., 14200., 10842., 12388., 13934.,
      15480., 11066., 12644., 14222., 15800., 11290., 12900., 14510., 16120.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}